In [4]:
import pandas as pd
import datetime
import glob
import json
import matplotlib.pyplot as plt
import numpy as np
import bokeh
import seaborn as sns
import pandas_profiling
import plotly
import plotly.graph_objects as go # Notwendig für Sankey Diagramm
import chart_studio.plotly as py
import pytz
In [5]:
#df= pd.read_csv("data/data1/tirol_sys_21.csv", error_bad_lines=False, sep=";", decimal=",")
#df= pd.read_csv("data/data3/synt_ohne_bat.csv", error_bad_lines=False, sep=";", parse_dates=['DateTime'])

#df= pd.read_csv("data/data1/tirol_sys_21.csv", error_bad_lines=False, sep=";", decimal=",")
#df= pd.read_csv("data/data3/synt_ohne_bat.csv", error_bad_lines=False, sep=";", parse_dates=['DateTime'])
In [6]:
##zum Einlesen der synthetischen Profile

#DF MIT MEDIAN:
#df= pd.read_csv("../data/data3/synt_mit_bat_median.csv", error_bad_lines=False, sep=",")

#Test mit Mittelwert:
df= pd.read_csv("data/data3/synt_mit_bat_mittelwert.csv", error_bad_lines=False, sep=";")

#Test mit Mean und 25% Trim oben und unten:
#df= pd.read_csv("../data/data3/synt_mit_bat_mittelwert_trimmed.csv", error_bad_lines=False, sep=",")
In [7]:
##Zum Einlesen von einzelnen Anlagen:
#df= pd.read_csv("../data/data2/tirol_sys_bat_2.csv", error_bad_lines=False, sep=";",  decimal=",")
In [8]:
df.head()
Out[8]:
DateTime DevWork_97 [Energy_Ws] FromBattToConsumer_0 [Energy_Wh] FromGenToBatt_0 [Energy_Wh] FromGenToConsumer_0 [Energy_Wh] FromGenToGrid_0 [Energy_Wh] FromGridToConsumer_0 [Energy_Wh] FromGrid_0 [Energy_Wh] StateOfCharge_254 [Percent] ToConsumer_0 [Energy_Wh]
0 2017-01-01 00:05:00+01:00 11940.30 3.81 0.0 0.0 0.0 39.65 39.65 20.23 43.46
1 2017-01-01 00:10:00+01:00 13675.57 4.31 0.0 0.0 0.0 44.69 44.70 20.08 49.01
2 2017-01-01 00:15:00+01:00 8791.61 2.90 0.0 0.0 0.0 46.38 46.39 20.00 49.28
3 2017-01-01 00:20:00+01:00 8645.13 2.74 0.0 0.0 0.0 41.69 41.70 19.85 44.43
4 2017-01-01 00:25:00+01:00 9079.74 2.90 0.0 0.0 0.0 44.09 44.13 19.77 46.99
In [9]:
df.dtypes
Out[9]:
DateTime                             object
DevWork_97 [Energy_Ws]              float64
FromBattToConsumer_0 [Energy_Wh]    float64
FromGenToBatt_0 [Energy_Wh]         float64
FromGenToConsumer_0 [Energy_Wh]     float64
FromGenToGrid_0 [Energy_Wh]         float64
FromGridToConsumer_0 [Energy_Wh]    float64
FromGrid_0 [Energy_Wh]              float64
StateOfCharge_254 [Percent]         float64
ToConsumer_0 [Energy_Wh]            float64
dtype: object
In [10]:
df['DateTime'] = pd.to_datetime(df['DateTime'], format="%Y-%m-%d", utc=True)
df['DateTime'] = df['DateTime'].dt.tz_convert('Europe/Berlin')
In [11]:
#RENAME COLUMNS:

df.columns = ['DateTime', 'DevWork', 'FromBatToCons', 'FromGenToBat','FromGenToCons', 'FromGenToGrid','FromGridToCons','FromGrid', 'StateOfCharge', 'ToCons']


'''
DF shape original:

DateTime                            datetime64[ns, Europe/Berlin]grou
DevWork_97 [Energy_Ws]                                    float64
FromBattToConsumer_0 [Energy_Wh]                            int64
FromGenToBatt_0 [Energy_Wh]                                 int64
FromGenToConsumer_0 [Energy_Wh]                           float64
FromGenToGrid_0 [Energy_Wh]                               float64
FromGridToConsumer_0 [Energy_Wh]                          float64
FromGrid_0 [Energy_Wh]                                    float64
ToConsumer_0 [Energy_Wh]                                  float64
dtype: object
'''
Out[11]:
'\nDF shape original:\n\nDateTime                            datetime64[ns, Europe/Berlin]grou\nDevWork_97 [Energy_Ws]                                    float64\nFromBattToConsumer_0 [Energy_Wh]                            int64\nFromGenToBatt_0 [Energy_Wh]                                 int64\nFromGenToConsumer_0 [Energy_Wh]                           float64\nFromGenToGrid_0 [Energy_Wh]                               float64\nFromGridToConsumer_0 [Energy_Wh]                          float64\nFromGrid_0 [Energy_Wh]                                    float64\nToConsumer_0 [Energy_Wh]                                  float64\ndtype: object\n'
In [12]:
df['FromGen'] = df['FromGenToBat'] + df['FromGenToCons'] + df['FromGenToGrid'] 
In [13]:
#Pandas Profiling
In [14]:
df.head()
Out[14]:
DateTime DevWork FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid StateOfCharge ToCons FromGen
0 2017-01-01 00:05:00+01:00 11940.30 3.81 0.0 0.0 0.0 39.65 39.65 20.23 43.46 0.0
1 2017-01-01 00:10:00+01:00 13675.57 4.31 0.0 0.0 0.0 44.69 44.70 20.08 49.01 0.0
2 2017-01-01 00:15:00+01:00 8791.61 2.90 0.0 0.0 0.0 46.38 46.39 20.00 49.28 0.0
3 2017-01-01 00:20:00+01:00 8645.13 2.74 0.0 0.0 0.0 41.69 41.70 19.85 44.43 0.0
4 2017-01-01 00:25:00+01:00 9079.74 2.90 0.0 0.0 0.0 44.09 44.13 19.77 46.99 0.0
In [15]:
df.dtypes
Out[15]:
DateTime          datetime64[ns, Europe/Berlin]
DevWork                                 float64
FromBatToCons                           float64
FromGenToBat                            float64
FromGenToCons                           float64
FromGenToGrid                           float64
FromGridToCons                          float64
FromGrid                                float64
StateOfCharge                           float64
ToCons                                  float64
FromGen                                 float64
dtype: object
In [16]:
#df['FromBatToCons'] = df['FromBatToCons'].astype(float)
In [17]:
from pandas_profiling import ProfileReport

profile = ProfileReport(df, title="Pandas Profiling Report  Synthetisches LP ohne Batterie")
In [18]:
profile
Out[18]:

Überschussmenge Monat/Tag visualisieren:

Es wird ein Subset aus der Überschussmenge gebildet (jeweils aggregiert nach Monat und Tag) Außerdem erfolgt noch eine Umrechnung auf kWh um eine bessere Vergleichbarkeit zu ermöglichen.

In [19]:
#hier werden die Daten nach Montaen und Tagen
überschuss_month = df.groupby(pd.Grouper(key='DateTime',freq='M')).agg({'FromGenToGrid':'sum', 'FromGen':'sum'}).reset_index()
überschuss_day = df.groupby(pd.Grouper(key='DateTime',freq='d')).agg({'FromGenToGrid':'sum'}).reset_index()
In [20]:
#Damit alle Werte nach Monaten ausgewertet werden können + Umwandlung in kWh

df_aggr=df.groupby(pd.Grouper(key='DateTime',freq='M')).sum().reset_index()
df_aggr['Datum'] = pd.to_datetime(df_aggr['DateTime']).dt.strftime('%Y-%m')
df_aggr['Jahr'] = pd.to_datetime(df_aggr['DateTime']).dt.strftime('%Y')
df_aggr['Monat'] = pd.to_datetime(df_aggr['DateTime']).dt.strftime('%m')

#da die Features FromGenToBat  und FromBatToCons nicht in allen Anlagen vorhanden ist:
try:
    df_aggr["FromBatToCons"] = df_aggr["FromBatToCons"]/1000
except:
        pass
try:
    df_aggr["FromGenToBat"] = df_aggr["FromGenToBat"]/1000
except:
        pass
    
df_aggr["FromGenToCons"] = df_aggr["FromGenToCons"]/1000
df_aggr["FromGenToGrid"] = df_aggr["FromGenToGrid"]/1000
df_aggr["FromGridToCons"] = df_aggr["FromGridToCons"]/1000
df_aggr["FromGrid"] = df_aggr["FromGrid"]/1000
df_aggr["ToCons"] = df_aggr["ToCons"]/1000
df_aggr["FromGen"] = df_aggr["FromGen"]/1000
del df_aggr['DateTime']
del df_aggr['DevWork']
In [21]:
df_aggr.head()
Out[21]:
FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid StateOfCharge ToCons FromGen Datum Jahr Monat
0 28.80237 32.34467 46.21086 20.26457 570.19483 573.24890 205467.91 645.20883 98.82010 2017-01 2017 01
1 63.30807 71.32471 114.20970 61.84646 292.35062 293.70539 296878.52 469.86939 247.38087 2017-02 2017 02
2 104.40979 119.55595 184.92749 177.12227 213.00861 213.60532 394340.67 502.34469 481.60571 2017-03 2017 03
3 102.75243 116.98282 192.34285 202.79860 176.11852 176.77510 385191.11 471.19308 512.12427 2017-04 2017 04
4 108.23059 124.36693 213.79734 345.69833 108.72271 110.13778 521896.47 430.74975 683.86260 2017-05 2017 05
In [22]:
#Jahresverbrauch an Strom:

verbr_monat = df_aggr.groupby(df_aggr.Datum ,as_index=True).sum().reset_index()
verbr_jahr = df_aggr.groupby(df_aggr.Jahr ,as_index=True).sum().reset_index()
In [23]:
verbr_jahr
#verbr_jahr.to_csv('Energiemenge_gesamt_Jahr_snyt_mittelwert.csv')
Out[23]:
Jahr FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid StateOfCharge ToCons FromGen
0 2017 1026.54770 1161.24316 1781.74020 1968.26715 3003.02638 3023.57085 4407466.79 5808.08044 4911.25051
1 2018 1128.46131 1254.00372 1927.14932 2076.50862 3129.61430 3155.95142 4530347.38 6184.87898 5257.66166
2 2019 1238.07232 1355.48732 1771.53453 1792.01301 3348.59877 3408.09973 4452353.11 6358.16769 4919.03486
3 2020 1215.98778 1337.97843 1934.65250 1882.76761 3317.44168 3390.61705 4509016.92 6468.07673 5155.39854
4 2021 136.64640 144.58067 188.76201 85.10389 903.46520 920.53361 613033.51 1228.87879 418.44657
In [24]:
verbr_jahr_round=verbr_jahr.round(2)
In [25]:
#verbr_jahr_round.to_csv('Energiemenge_gesamt_Jahr_snyt_round_median.csv')
verbr_jahr_round
Out[25]:
Jahr FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid StateOfCharge ToCons FromGen
0 2017 1026.55 1161.24 1781.74 1968.27 3003.03 3023.57 4407466.79 5808.08 4911.25
1 2018 1128.46 1254.00 1927.15 2076.51 3129.61 3155.95 4530347.38 6184.88 5257.66
2 2019 1238.07 1355.49 1771.53 1792.01 3348.60 3408.10 4452353.11 6358.17 4919.03
3 2020 1215.99 1337.98 1934.65 1882.77 3317.44 3390.62 4509016.92 6468.08 5155.40
4 2021 136.65 144.58 188.76 85.10 903.47 920.53 613033.51 1228.88 418.45
In [26]:
#Kontrolle
#verbr_monat.head()
In [27]:
#verbr_monat.distplot('FromGen','ToCons')
In [28]:
#überschuss_month['DateTime'] = pd.to_datetime(überschuss_month['DateTime'], format="%Y-%m")

überschuss_month['Datum'] = pd.to_datetime(überschuss_month['DateTime']).dt.strftime('%Y-%m')
überschuss_month['Jahr'] = pd.to_datetime(überschuss_month['DateTime']).dt.strftime('%Y')
überschuss_month['Monat'] = pd.to_datetime(überschuss_month['DateTime']).dt.strftime('%m')
In [29]:
#überschuss_month['FromGenToGrid'] = (überschuss_month['FromGenToGrid']/1000)
del überschuss_month['DateTime']
In [30]:
überschuss_month["FromGenToGrid"] = (überschuss_month["FromGenToGrid"]/1000)
überschuss_month["FromGen"] = (überschuss_month["FromGen"]/1000)
In [31]:
indexNames = überschuss_month[überschuss_month['Jahr'] == '2021'].index
überschuss_month.drop(indexNames , inplace=True)
#kontrolle:
überschuss_month.head()
Out[31]:
FromGenToGrid FromGen Datum Jahr Monat
0 20.26457 98.82010 2017-01 2017 01
1 61.84646 247.38087 2017-02 2017 02
2 177.12227 481.60571 2017-03 2017 03
3 202.79860 512.12427 2017-04 2017 04
4 345.69833 683.86260 2017-05 2017 05
In [32]:
#nun werden die Daten pivotiert, damit später die Jahre untereinander verglichen werden können
piv = pd.pivot_table(überschuss_month, index=['Monat'], columns=['Jahr'], values=['FromGenToGrid', 'FromGen'])
piv.dtypes
Out[32]:
               Jahr
FromGen        2017    float64
               2018    float64
               2019    float64
               2020    float64
FromGenToGrid  2017    float64
               2018    float64
               2019    float64
               2020    float64
dtype: object
In [33]:
#piv.reset_index()
#Kontrolle:
#piv.head()
In [34]:
piv.plot(figsize=(15,10))
plt.xlabel("Monat")
plt.ylabel("Überschusseinspeisung in kWh")
legend = plt.legend(title="Überschusseinspeisung, Jahr",
                    loc=1, fontsize='large', fancybox=True)
In [35]:
piv['FromGen','2017'].plot(figsize=(15,10))
piv['FromGen','2018'].plot(figsize=(15,10))
piv['FromGen','2019'].plot(figsize=(15,10))
piv['FromGen','2020'].plot(figsize=(15,10))
plt.xlabel("Monat") 
plt.ylabel("Überschusseinspeisung in kWh")
legend = plt.legend(title="Überschusseinspeisung, Jahr",
                    loc=1, fontsize='large', fancybox=True)
In [36]:
#Diese Grafik visualisiert, wie viel kWh Pro Jahr von der PV-Anlage ins Netz eingespeist werden (saisonaler Vergleich)
#Diese Menge an Überschuss ist das Potential, das für den Betrieb einen Elektrofahrzeuges genutzt werden könnte.
In [ ]:
 
In [37]:
#piv.head(200)
#piv.to_csv('pivot_test.csv', index = False)
In [38]:
#Nachfolgend werden die Überschussmengen, welche ins Netz eingespeist werden, anhand der Menge verglichen. Dazu wurden Violin und Boxplots verwendet.
#Speziell der erste Violinplot wäre aus Sicht des Autors optisch interessant gewesen. Da die Eigenschaft des Violinplots allerdings die Aussagekraft verfälscht (der Violinplot läuft im negativen Wertebreeich aus), wurde für die finale Arbeit der Boxpot benutzt.
In [39]:
#Falls nur FromGenToGrid wieder in piv sein soll:
#piv = pd.pivot_table(überschuss_month, index=['Monat'], columns=['Jahr'], values=['FromGenToGrid'])
In [40]:
plt.figure(figsize=(12, 10))
ax = sns.violinplot(#x="Monat", y="FromGenToGrid",
                    data=piv["FromGenToGrid"], split=True, palette="Set2", title="abc",
                    scale="count", inner="quartile")
In [41]:
plt.figure(figsize=(12, 10))
ax = sns.violinplot(data=piv, figsize=(200, 100))
In [42]:
plt.figure(figsize=(12, 10))
sns.boxplot(data=piv["FromGenToGrid"])
sns.despine(offset=10, trim=True)
plt.xlabel("Jahr") 
plt.ylabel("Überschusseinspeisung in kWh pro Monat")
Out[42]:
Text(0, 0.5, 'Überschusseinspeisung in kWh pro Monat')
In [43]:
plt.figure(figsize=(12, 10))
sns.boxplot(data=piv)
sns.despine(offset=10, trim=True)
plt.xlabel("Jahr") 
plt.ylabel("Überschusseinspeisung in kWh pro Monat")
Out[43]:
Text(0, 0.5, 'Überschusseinspeisung in kWh pro Monat')
In [44]:
#Verbrauch und Erzeugung:
In [45]:
df2=verbr_monat
df2['Jahr'] = pd.to_datetime(verbr_monat['Datum']).dt.strftime('%Y')
df2['Monat'] = pd.to_datetime(verbr_monat['Datum']).dt.strftime('%m')
In [46]:
#Kontrolle
#df2.head()
In [47]:
indexNames = df2[df2['Jahr'] == '2021'].index
df2.drop(indexNames , inplace=True)
#kontrolle:
#df2.head()
In [48]:
piv2= pd.pivot_table(df2, index=['Monat'], columns=['Jahr'],
values=['FromBatToCons','FromGenToBat','FromGenToCons','FromGenToGrid','FromGridToCons','FromGrid','ToCons','FromGen'])
plt.figure(figsize=(12, 10)) sns.lineplot(data=piv2) sns.despine(offset=10, trim=True) plt.xlabel("Monat") plt.ylabel("kWh")
In [49]:
#Es wurde ein Durchschnitt aus den 4 Jahren gebildet und diese hier miteinander verglichen.
In [50]:
piv2['FromGen','2018'].plot(figsize=(15,10))
piv2['ToCons','2018'].plot(figsize=(15,10))
plt.xlabel("Monat") 
plt.ylabel("kWh")
legend = plt.legend(title="Erzeugung und Verbrauch, Jahr",
                    loc=1, fontsize='large', fancybox=True)
In [51]:
piv2['FromGen'].plot(figsize=(15,10))
plt.xlabel("Monat") 
plt.ylabel("kWh")
legend = plt.legend(title="Erzeugung, Jahr",
                    loc=1, fontsize='large', fancybox=True)
In [52]:
piv2['ToCons'].plot(figsize=(15,10))
plt.xlabel("Monat") 
plt.ylabel("kWh")
legend = plt.legend(title="Verbrauch, Jahr",
                    loc=1, fontsize='large', fancybox=True)
In [53]:
#Woche im Sommmer

#start_date="2019-09-01"
#end_date="2019-09-07"

start_date="2019-08-18"
end_date="2019-08-24"

zeit = (df['DateTime'] > start_date) & (df['DateTime'] <= end_date)
zeit = df.loc[zeit]
In [54]:
zeit.plot(figsize=(15,10),x="DateTime", y=["FromGen", "ToCons", 'FromGenToGrid'])
#df.plot(x="DateTime", y=["FromGen", "ToCons"])
plt.xlabel("Zeit") 
plt.ylabel("Wh")
legend = plt.legend(title="Lastprofil im Sommer",
                    loc=1, fontsize='large', fancybox=True)
In [ ]:
 
In [55]:
#Woche bei maximaler Tageslänge (Schlechtwetter)
start_date="2019-06-18"
end_date="2019-06-24"

#start_date="2019-08-18"
#end_date="2019-08-24"

zeit = (df['DateTime'] > start_date) & (df['DateTime'] <= end_date)
zeit = df.loc[zeit]

zeit.plot(figsize=(15,10),x="DateTime", y=["FromGen", "ToCons", 'FromGenToGrid'])
#df.plot(x="DateTime", y=["FromGen", "ToCons"])
plt.xlabel("Zeit") 
plt.ylabel("Wh")
legend = plt.legend(title="Lastprofil bei maximaler Tageslänge",
                    loc=1, fontsize='large', fancybox=True)
In [56]:
#kürzester Tag 
start_date="2019-12-16"
end_date="2019-12-23"
zeit = (df['DateTime'] > start_date) & (df['DateTime'] <= end_date)
zeit = df.loc[zeit]
In [57]:
zeit.plot(figsize=(15,10),x="DateTime", y=["FromGen", "ToCons", 'FromGenToGrid'])
#df.plot(x="DateTime", y=["FromGen", "ToCons"])
plt.xlabel("Zeit") 
plt.ylabel("Wh")
legend = plt.legend(title="Überschusseinspeisung, Jahr",
                    loc=2, fontsize='large', fancybox=True)
In [58]:
#Hier ist eine übersicht, über die erzeugungssschwächste Zeit im Jahr ersichtlich.
#Anhand der historischen Wetterdaten von timeanddate.de lässt sich erkennen, dass gerade am 21. und 22.12 sehr schlechte Wetterbedingunen herrschten. Außerdem fallen beide Tage auf ein Wochenende, was den Stromverbrauch sichtlich erhöht.
#Diese Kombination aus Wintersonnenwende und schlechtem Wetter zeigt, dass zu dieser Zeit quasi keine Erzeugung stattfindet


#https://www.timeanddate.de/wetter/oesterreich/innsbruck/rueckblick?month=12&year=2019
In [59]:
# Differenz Erzeugung/Bedarf pro Tag:
In [60]:
tageswerte = df.groupby(pd.Grouper(key='DateTime',freq='d')).agg({'FromGen':'sum'},{'FromGen':'sum'}).reset_index()
In [61]:
df_tag=df.groupby(pd.Grouper(key='DateTime',freq='d')).sum().reset_index()

df_tag["Überschuss"] = df_tag["FromGen"]-df_tag["ToCons"]


df_tag['Datum'] = pd.to_datetime(df_tag['DateTime']).dt.strftime('%Y-%m-%d')
df_tag['Jahr'] = pd.to_datetime(df_tag['DateTime']).dt.strftime('%Y')
df_tag['Monat'] = pd.to_datetime(df_tag['DateTime']).dt.strftime('%m')
df_tag['Tag'] = pd.to_datetime(df_tag['DateTime']).dt.strftime('%d')

#da die Features FromGenToBat  und FromBatToCons nicht in allen Anlagen vorhanden ist:
try:
    df_tag["FromBatToCons"] = df_tag["FromBatToCons"]/1000
except:
        pass
try:
    df_tag["FromGenToBat"] = df_tag["FromGenToBat"]/1000
except:
        pass
    
df_tag["FromGenToCons"] = df_tag["FromGenToCons"]/1000
df_tag["FromGenToGrid"] = df_tag["FromGenToGrid"]/1000
df_tag["FromGridToCons"] = df_tag["FromGridToCons"]/1000
df_tag["FromGrid"] = df_tag["FromGrid"]/1000
df_tag["ToCons"] = df_tag["ToCons"]/1000
df_tag["FromGen"] = df_tag["FromGen"]/1000
df_tag["Überschuss"]= df_tag["Überschuss"]/1000
del df_tag['DateTime']
del df_tag['DevWork']
try:
    del df_tag['StateOfCharge']
except:
    pass
In [62]:
#Kontrolle
#df_tag.head()
In [63]:
#Der Tag, an dem der größte Erzeugungsüberschuss stattfand:
In [64]:
df_tag.loc[df_tag['Überschuss'].idxmax()]
Out[64]:
FromBatToCons        3.47882
FromGenToBat         4.13481
FromGenToCons        8.58688
FromGenToGrid       19.18006
FromGridToCons       1.23083
FromGrid             1.24596
ToCons              13.29663
FromGen             31.90175
Überschuss          18.60512
Datum             2017-06-18
Jahr                    2017
Monat                     06
Tag                       18
Name: 168, dtype: object
In [65]:
#Der Tag, an dem die größte Diskrepanz zwischen Verbrauch und Erzeugung lag:
In [66]:
df_tag.loc[df_tag['Überschuss'].idxmin()]
Out[66]:
FromBatToCons        1.21837
FromGenToBat          0.4321
FromGenToCons        0.76409
FromGenToGrid        0.01335
FromGridToCons      23.61351
FromGrid            24.01677
ToCons              25.59611
FromGen              1.20954
Überschuss         -24.38657
Datum             2019-01-26
Jahr                    2019
Monat                     01
Tag                       26
Name: 755, dtype: object
In [67]:
'''
#GO SIND AUSKOMMENTIERT, weil sie sehr rechensintensiv bei der Anzeige sind in großen Mengen und die Performance stören
'''
import plotly.graph_objects as go
import numpy as np

x = df_tag["Datum"]
y = df_tag["Überschuss"]

fig = go.Figure(data=go.Scatter(x=x, y=y), layout_xaxis_range=["2017-01-01", "2020-12-31"])

fig.add_shape(type='line',
                x0=min(x),
                y0=0,
                x1=max(x),
                y1=0,
                line=dict(color='Red',),
                xref='x',
                #yref='y'
)

fig.show()
In [70]:
''' ähnliches Diagamm wie oben, jedoch grafisch weniger ausgearbeitet, deshalb nicht notwendig
'''
df_tag.plot(figsize=(15,10),x="Datum", y=["Überschuss"])


#df.plot(x="DateTime", y=["FromGen", "ToCons"])
plt.xlabel("Zeit") 
plt.ylabel("kWh")
legend = plt.legend(title="Erzeugungsüberschuss pro Tag:",
                    loc=2, fontsize='large', fancybox=True)
                    
In [71]:
# Barplot der monatlichen Überschüsse bzw. Mindermengen:
In [72]:
df_tag2=df_tag.groupby(pd.Grouper(key='Datum')).sum().reset_index()
In [73]:
#df_tag2=df_mon
df_tag2['Datum'] = pd.to_datetime(df_tag2['Datum']).dt.strftime('%Y-%m')
In [ ]:
 
In [74]:
#Kontrolle
#df_mon.dtypes
#df_tag2.head()
In [75]:
dfx = df_tag2.groupby(df_tag2.Datum, as_index=True).sum().reset_index()
In [76]:
#dfx["Datum"]=dfx[""]"-"dfx[""]
#dfx.head()
In [ ]:
 
In [77]:
#sns.set_theme(style="whitegrid")
colors = [1 if c < 0 else 0 for c in dfx["Überschuss"]]
color = ["#63F502", "#EF3C2B", "#4374B3"]
#cmap = sns.diverging_palette(220, 20, as_cmap=True)

# Draw a nested barplot by species and sex
g = sns.catplot(
    data=dfx, kind="bar",
    x="Datum", y="Überschuss", 
    hue=colors,
    ci="sd", palette=color, alpha=1, height=12,
      

    
    
    
)
[plt.setp(ax.get_xticklabels(), rotation=45) for ax in g.axes.flat]
#g.ax.axhline(225),
g.despine(left=True)
g.set_axis_labels("Zeitraum in Monaten", "Differenz zwischen Gesamterzeugung und -verbrauch (kWh)")
#g.legend.set_title("Überschussmengen")
g._legend.remove()
In [78]:
#Überschussmengen mit BEV

#sns.set_theme(style="whitegrid")
colors = [1 if c < 225 else 0 for c in dfx["Überschuss"]]
color = ["#63F502", "#EF3C2B", "#4374B3"]
#cmap = sns.diverging_palette(220, 20, as_cmap=True)

# Draw a nested barplot by species and sex
g = sns.catplot(
    data=dfx, kind="bar",
    x="Datum", y="Überschuss", 
    hue=colors,
    ci="sd", palette=color, alpha=1, height=12,
      

    
    
    
)
[plt.setp(ax.get_xticklabels(), rotation=45) for ax in g.axes.flat]
g.ax.axhline(225),
g.despine(left=True)
g.set_axis_labels("Zeitraum in Monaten", "Differenz zwischen Gesamterzeugung und -verbrauch (kWh)")
#g.legend.set_title("Überschussmengen")
g._legend.remove()
In [79]:
colors = ['' if c < 0 else 0 for c in dfx["Überschuss"]]
#data=df_mon
#x = df_mon["Datum"]
#y = df_mon["Überschuss"]

x = dfx["Datum"]
y = dfx["Überschuss"]
  
# setting the dimensions of the plot
fig, ax = plt.subplots(figsize=(20, 12))
  
# drawing the plot
sns.barplot(x, y, ax=ax, hue=colors)
plt.xticks(rotation=45)
plt.show()
C:\ProgramData\Anaconda3\lib\site-packages\seaborn\_decorators.py:43: FutureWarning:

Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.

In [80]:
#die obige Grafik stellt dar, stellt die Differenz zwischen Gesamterzeugung und -Verbrauch dar. Ist der Wert positiv dargestellt (blau), wurde mehr erzeugt als verbraucht - negative Werte sind rot dargestellt und zeigen an, wie viel kWh in dem Monat merh verbraucht als erzeugt wurden.
In [81]:
dfx= df_tag[['Jahr', 'Monat', 'Tag', 'FromGen', 'Überschuss']].copy()
In [82]:
#Kontrolle
#dfx.head()

Nun soll das Potential der Überschussmengen erneut beleuchtet werden.

In [83]:
'''
Während eingangs immer die Differenz zwischen Erzeugung und Verbrauch über einen definierten Zeitraum untersucht wurde, sollen nun
nur die Messungen, in denen mehr erzeugt als verbraucht wurde, untersucht werden.
Hintergrund:
Diese Auswertung soll visualisieren, wie viel Überschuss für ein Ladesystem anfällt, wenn dieser eben nicht in einem Speicher gesammelt wird,
um später wieder dem Haushaltsverbrauch zugeführt wird.

Notwendige Energie wird also vom Netz bezogen und nicht durch frühere Überschüsse kompensiert, da diese dem Elektrofahrzeug zugeführt wird

Dazu wird das Feature "Mehrmenge" erzeugt, welches die Differenz zwischen der gesamten Erzeugungsmenge und dem Eigenverbrauch der Kunden darstellt
'''
Out[83]:
'\nWährend eingangs immer die Differenz zwischen Erzeugung und Verbrauch über einen definierten Zeitraum untersucht wurde, sollen nun\nnur die Messungen, in denen mehr erzeugt als verbraucht wurde, untersucht werden.\nHintergrund:\nDiese Auswertung soll visualisieren, wie viel Überschuss für ein Ladesystem anfällt, wenn dieser eben nicht in einem Speicher gesammelt wird,\num später wieder dem Haushaltsverbrauch zugeführt wird.\n\nNotwendige Energie wird also vom Netz bezogen und nicht durch frühere Überschüsse kompensiert, da diese dem Elektrofahrzeug zugeführt wird\n\nDazu wird das Feature "Mehrmenge" erzeugt, welches die Differenz zwischen der gesamten Erzeugungsmenge und dem Eigenverbrauch der Kunden darstellt\n'
In [84]:
#df6 gibt alle Werte in Wh an, df7 in kWh (da gruppiert)
df6= df
#df.head()
In [85]:
df6['Mehrmenge']=df6['FromGen']-df6['FromGenToCons']
In [86]:
df6
Out[86]:
DateTime DevWork FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid StateOfCharge ToCons FromGen Mehrmenge
0 2017-01-01 00:05:00+01:00 11940.30 3.81 0.0 0.0 0.0 39.65 39.65 20.23 43.46 0.0 0.0
1 2017-01-01 00:10:00+01:00 13675.57 4.31 0.0 0.0 0.0 44.69 44.70 20.08 49.01 0.0 0.0
2 2017-01-01 00:15:00+01:00 8791.61 2.90 0.0 0.0 0.0 46.38 46.39 20.00 49.28 0.0 0.0
3 2017-01-01 00:20:00+01:00 8645.13 2.74 0.0 0.0 0.0 41.69 41.70 19.85 44.43 0.0 0.0
4 2017-01-01 00:25:00+01:00 9079.74 2.90 0.0 0.0 0.0 44.09 44.13 19.77 46.99 0.0 0.0
... ... ... ... ... ... ... ... ... ... ... ... ...
438547 2021-03-03 21:40:00+01:00 26521.00 11.63 0.0 0.0 0.0 0.00 0.00 83.00 11.63 0.0 0.0
438548 2021-03-03 21:45:00+01:00 26532.00 11.62 0.0 0.0 0.0 0.00 0.00 83.00 11.62 0.0 0.0
438549 2021-03-03 21:50:00+01:00 26575.00 11.65 0.0 0.0 0.0 0.00 0.00 83.00 11.65 0.0 0.0
438550 2021-03-03 21:55:00+01:00 26449.00 11.60 0.0 0.0 0.0 0.00 0.00 82.00 11.61 0.0 0.0
438551 2021-03-03 22:00:00+01:00 26341.00 11.61 0.0 0.0 0.0 0.00 0.00 82.00 11.61 0.0 0.0

438552 rows × 12 columns

In [87]:
#df7=df6

df7=df6.groupby(pd.Grouper(key='DateTime',freq='d')).sum().reset_index()


df7['Datum'] = pd.to_datetime(df7['DateTime']).dt.strftime('%Y-%m-%d')
df7['Jahr'] = pd.to_datetime(df7['DateTime']).dt.strftime('%Y')
df7['Monat'] = pd.to_datetime(df7['DateTime']).dt.strftime('%m')
df7['Tag'] = pd.to_datetime(df7['DateTime']).dt.strftime('%d')

#da die Features FromGenToBat  und FromBatToCons nicht in allen Anlagen vorhanden ist:
try:
    df7["FromBatToCons"] = df7["FromBatToCons"]/1000
except:
        pass
try:
    df7["FromGenToBat"] = df7["FromGenToBat"]/1000
except:
        pass
    
df7["FromGenToCons"] = df7["FromGenToCons"]/1000
df7["FromGenToGrid"] = df7["FromGenToGrid"]/1000
df7["FromGridToCons"] = df7["FromGridToCons"]/1000
df7["FromGrid"] = df7["FromGrid"]/1000
df7["ToCons"] = df7["ToCons"]/1000
df7["FromGen"] = df7["FromGen"]/1000
df7["Mehrmenge"]= df7["Mehrmenge"]/1000
del df7['DateTime']
try:
    del df7['DevWork']
except:
    pass
try:
    del df7['StateOfCharge']
except:
    pass
In [88]:
#del df7["mehrmenge"]
#df7 Mengen in kWh und nach Tag gruppiert
#Kontrolle
df7.head(500)
Out[88]:
FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid ToCons FromGen Mehrmenge Datum Jahr Monat Tag
0 1.73883 2.25195 2.81285 1.38546 14.02272 14.20076 18.57436 6.45026 3.63741 2017-01-01 2017 01 01
1 1.93826 2.17613 3.20889 0.63799 15.92414 15.97706 21.07149 6.02301 2.81412 2017-01-02 2017 01 02
2 1.94597 2.05016 3.01617 0.62342 16.21786 16.24891 21.18017 5.68975 2.67358 2017-01-03 2017 01 03
3 0.23456 0.14444 0.51294 0.00242 20.49176 20.55308 21.23943 0.65980 0.14686 2017-01-04 2017 01 04
4 0.04548 0.04519 0.09328 0.00101 23.71679 23.80090 23.85599 0.13948 0.04620 2017-01-05 2017 01 05
... ... ... ... ... ... ... ... ... ... ... ... ... ...
495 3.49405 4.78514 7.92992 15.16388 2.09852 2.10583 13.52252 27.87894 19.94902 2018-05-11 2018 05 11
496 4.01628 4.57208 6.94392 12.88016 2.56866 2.57091 13.52893 24.39616 17.45224 2018-05-12 2018 05 12
497 4.26880 4.49071 6.54128 12.26238 2.88785 2.89249 13.69796 23.29437 16.75309 2018-05-13 2018 05 13
498 4.56437 4.30001 6.23959 8.11393 3.31288 3.31557 14.11706 18.65353 12.41394 2018-05-14 2018 05 14
499 3.40602 3.96354 4.79347 1.36696 6.39827 6.40659 14.59782 10.12397 5.33050 2018-05-15 2018 05 15

500 rows × 13 columns

In [89]:
jahr_mehr=df7['Mehrmenge'].sum()
jahr_mehr
Out[89]:
13057.953580000001
In [90]:
jahr_erz=df7['FromGen'].sum()
jahr_erz
Out[90]:
20661.792139999998
In [91]:
#Da jetzt beide Dataframes vorbereitet sind, erfolgt nun die geplante Visualisierung der Daten:
In [92]:
#x=["2020-01-01","2017-05-22"]

def mymehrmenge():
    zeit = (df7['Datum'] > start_date) & (df7['Datum'] <= end_date)
    zeit = df7.loc[zeit]
    
    zeit.plot(figsize=(15,10),x="Datum", y=['Mehrmenge'])
    #df.plot(x="DateTime", y=["FromGen", "ToCons"])
    #plt.xticks(x)
    plt.xlabel("Zeit") 
    plt.ylabel("kWh")
    legend = plt.legend(title="Lastprofil", loc=1, fontsize='large', fancybox=True)
                       
In [93]:
start_date="2020-01-01"
end_date="2020-12-31"
mymehrmenge()
In [ ]:
 
In [94]:
# Gesamtübersicht Stromfluss pro Jahr:
#Dazu werden die gesamten Werte der Jahre 2017-2020 zusammengeführt und daraus der Durchschnitt gebildet:
In [95]:
df3=verbr_jahr_round
In [96]:
df3=df3.drop([4]) #2021 wieder entfernen, damit vier volle Jahre da sind
del df3["StateOfCharge"] #Dieses Feature kann man nicht als Summe übers Jahr nutzen
df3["Jahr"].to_string()
df4=df3.append(df3.mean(numeric_only=True), ignore_index=True)
df4.at[4,'Jahr'] = "Mittel"
In [97]:
df4
Out[97]:
Jahr FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid ToCons FromGen
0 2017 1026.5500 1161.2400 1781.7400 1968.27 3003.03 3023.57 5808.0800 4911.250
1 2018 1128.4600 1254.0000 1927.1500 2076.51 3129.61 3155.95 6184.8800 5257.660
2 2019 1238.0700 1355.4900 1771.5300 1792.01 3348.60 3408.10 6358.1700 4919.030
3 2020 1215.9900 1337.9800 1934.6500 1882.77 3317.44 3390.62 6468.0800 5155.400
4 Mittel 1152.2675 1277.1775 1853.7675 1929.89 3199.67 3244.56 6204.8025 5060.835
In [98]:
#df5 ist nun ein Gesamtwert über alle Mengen in einem durchschnittlichen Jahr:
df5=df4.loc[[4]]
df5
Out[98]:
Jahr FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid ToCons FromGen
4 Mittel 1152.2675 1277.1775 1853.7675 1929.89 3199.67 3244.56 6204.8025 5060.835
In [99]:
# SANKEY:
In [100]:
color_link=[
'#EBBAB5',
'#90EE90',
'#FEF3C7',
'#CBB4D5',
'#CBB4D5',
'#A6E3D7', 
]

color_node=[
'#d90d39',
'#A4C964',
'#FEF3C7',
#'#CBB4D5',
'#d90d39',
'#CBB4D5',
'#A6E3D7', 
]



#           0          1          2         3        4
label = ["FromGrid", "FromGen", "ToCons", "Grid", "Battery"]
source = [0, 1, 1, 1, 4]
target = [2, 2, 3, 4, 2]
value = [df5["FromGridToCons"], df5["FromGenToCons"], df5["FromGenToGrid"], df5["FromGenToBat"], df5["FromBatToCons"]]
# data to dict, dict to sankey
link = dict(source = source, target = target, value = value, color=color_link)
node = dict(label = label, pad=50, thickness=5, color=color_node)
data = go.Sankey(link = link, node=node)
# plot
fig = go.Figure(data)
fig.show()
In [101]:
#Dieses SANKEY-Diagramm visualisiert den Fluss an kWh in einem durchschnittlichem Jahr.
In [ ]:
 

Stromfluss mittels SANKEY-Diagramme für einzelne Tage/Monate:

In [102]:
#da wir das Sankey-Diagramm nun zu verschiedensten Zeiten vergleichen möchten, wird es in eine Funktion verpackt:

def mysankey():  
    label = ["FromGrid", "FromGen", "ToCons", "Grid", "Battery"]
    source = [0, 1, 1, 1, 4]
    target = [2, 2, 3, 4, 2]
    value = [dft["FromGridToCons"], dft["FromGenToCons"], dft["FromGenToGrid"], dft["FromGenToBat"], dft["FromBatToCons"]]
    # data to dict, dict to sankey
    link = dict(source = source, target = target, value = value, color=color_link)
    node = dict(label = label, pad=50, thickness=5, color=color_node)
    data = go.Sankey(link = link, node=node)
    # plot
    fig = go.Figure(data)
    fig.show()
In [103]:
# sankey für: 21.6.2020
dft=df_tag.loc[df_tag['Datum'] == '2020-06-21']
mysankey()
In [104]:
# sankey für Winter: 21.12.2020
dft=df_tag.loc[df_tag['Datum'] == '2020-12-21']
mysankey()
In [105]:
# sankey für Sommer: 21.6.2020
dft=df_tag.loc[df_tag['Datum'] == '2020-06-21']
mysankey()
In [106]:
# sankey für Jahr
dft=df4.loc[df4['Jahr'] == '2020']
mysankey()

Sankey für Monate:

In [107]:
#df7.dtypes
In [108]:
#Kontrolle
#df7.head()
In [109]:
df8=df7.groupby(["Jahr", "Monat"]).sum().reset_index()
df8['Datum']=df8["Jahr"]+"-"+df8["Monat"]
In [110]:
df8.dtypes
Out[110]:
Jahr               object
Monat              object
FromBatToCons     float64
FromGenToBat      float64
FromGenToCons     float64
FromGenToGrid     float64
FromGridToCons    float64
FromGrid          float64
ToCons            float64
FromGen           float64
Mehrmenge         float64
Datum              object
dtype: object
In [111]:
df8.head()
Out[111]:
Jahr Monat FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid ToCons FromGen Mehrmenge Datum
0 2017 01 28.80237 32.34467 46.21086 20.26457 570.19483 573.24890 645.20883 98.82010 52.60924 2017-01
1 2017 02 63.30807 71.32471 114.20970 61.84646 292.35062 293.70539 469.86939 247.38087 133.17117 2017-02
2 2017 03 104.40979 119.55595 184.92749 177.12227 213.00861 213.60532 502.34469 481.60571 296.67822 2017-03
3 2017 04 102.75243 116.98282 192.34285 202.79860 176.11852 176.77510 471.19308 512.12427 319.78142 2017-04
4 2017 05 108.23059 124.36693 213.79734 345.69833 108.72271 110.13778 430.74975 683.86260 470.06526 2017-05
In [112]:
def mysankey_monat():  
    label = ["FromGrid", "FromGen", "ToCons", "Grid", "Battery"]
    source = [0, 1, 1, 1, 4]
    target = [2, 2, 3, 4, 2]
    value = [dfm["FromGridToCons"], dfm["FromGenToCons"], dfm["FromGenToGrid"], dfm["FromGenToBat"], dfm["FromBatToCons"]]
    # data to dict, dict to sankey
    link = dict(source = source, target = target, value = value, color=color_link)
    node = dict(label = label, pad=50, thickness=5, color=color_node)
    data = go.Sankey(link = link, node=node)
    # plot
    fig = go.Figure(data)
    fig.show()
In [113]:
# sankey für Juni 2020
dfm=df8.loc[df8['Datum'] == '2017-05']
#mysankey_monat()
In [114]:
# SANKEY FÜR BELIEBIGES MONAT HIER EINGEBEN:
dfm=df8.loc[df8['Datum'] == '2020-11']
#mysankey_monat()
In [115]:
#dfx.head()
In [116]:
#Für Jahre:
In [117]:
dfj=df7.groupby(["Jahr"]).sum().reset_index()
dfj
Out[117]:
Jahr FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid ToCons FromGen Mehrmenge
0 2017 1026.54770 1161.24316 1781.74020 1968.26715 3003.02638 3023.57085 5808.08044 4911.25051 3129.51031
1 2018 1128.46131 1254.00372 1927.14932 2076.50862 3129.61430 3155.95142 6184.87898 5257.66166 3330.51234
2 2019 1238.07232 1355.48732 1771.53453 1792.01301 3348.59877 3408.09973 6358.16769 4919.03486 3147.50033
3 2020 1215.98778 1337.97843 1934.65250 1882.76761 3317.44168 3390.61705 6468.07673 5155.39854 3220.74604
4 2021 136.64640 144.58067 188.76201 85.10389 903.46520 920.53361 1228.87879 418.44657 229.68456
In [118]:
'JAHR AUSWÄHLEN'
dfm=dfj.loc[dfj['Jahr'] == '2020']
mysankey_monat()
In [119]:
##Einzelne zufällige Tage:
In [120]:
#''' 
#GO IST WIEDER AUSKOMMENTIERT!
x = df["DateTime"]
y = df["FromGen"]
y = df["ToCons"]

fig = go.Figure(data=go.Scatter(x=x, y=y), layout_xaxis_range=["2017-06-25", "2017-06-30"])

'''fig.add_shape(type='line',
                x0=min(x),
                y0=0,
                x1=max(x),
                y1=0,
                line=dict(color='Red',),
                xref='x',
                #yref='y'
                
)'''

fig.show()

#'''
In [121]:
#'''
#AUFGURND DER EXTERM SCHLECHTEN PERFOMANZ von Plotly Graphical Objects bei solch einer enormen Menge an Werten, wurde dieser Plot entfernt:
fig = go.Figure([
    
    go.Scatter(
        name='Erzeugung',
        x=df['DateTime'],
        y=df['FromGen'],
        mode='markers+lines',
        marker=dict(color='red', size=2),
        showlegend=True
    ),
    go.Scatter(
        name='Verbrauch',
        x=df['DateTime'],
        y=df['ToCons'],
        mode='lines',
        marker=dict(color="#444"),
        line=dict(width=1),
        showlegend=False
    )])
#fig.update_layout(
#layout_xaxis_range=["2017-06-25", "2017-06-30"])

#'''
In [122]:
#fig.show()
In [ ]:
 
In [123]:
##Wenn es sich um eine Anlage mit vorhandenem Batteriespeicher handelt, soll dieser abschließend hier auch noch untersucht werden:
In [124]:
if 'StateOfCharge' in df:
   print("True") 
else:
    print("Die Anlage besitzt keinen Batteriespeicher")
True
In [125]:
#df.head()
In [126]:
df_bat=df
df_bat['Datum'] = pd.to_datetime(df_bat['DateTime']).dt.strftime('%Y-%m')
In [ ]:
 
In [141]:
'''

x = df["Datum"]
y = df_bat["StateOfCharge"]

fig = go.Figure(data=go.Scatter(x=x, y=y), layout_xaxis_range=["2019-06-01", "2019-06-02"])

fig.add_shape(type='line',
                x0=min(x),
                y0=0,
                x1=max(x),
                y1=0,
                line=dict(color='Red',),
                xref='x',
                #yref='y'
)

fig.show()
'''
Out[141]:
'\n\nx = df["Datum"]\ny = df_bat["StateOfCharge"]\n\nfig = go.Figure(data=go.Scatter(x=x, y=y), layout_xaxis_range=["2019-06-01", "2019-06-02"])\n\nfig.add_shape(type=\'line\',\n                x0=min(x),\n                y0=0,\n                x1=max(x),\n                y1=0,\n                line=dict(color=\'Red\',),\n                xref=\'x\',\n                #yref=\'y\'\n)\n\nfig.show()\n'
In [128]:
df_bat.set_index('DateTime')
Out[128]:
DevWork FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid StateOfCharge ToCons FromGen Mehrmenge Datum
DateTime
2017-01-01 00:05:00+01:00 11940.30 3.81 0.0 0.0 0.0 39.65 39.65 20.23 43.46 0.0 0.0 2017-01
2017-01-01 00:10:00+01:00 13675.57 4.31 0.0 0.0 0.0 44.69 44.70 20.08 49.01 0.0 0.0 2017-01
2017-01-01 00:15:00+01:00 8791.61 2.90 0.0 0.0 0.0 46.38 46.39 20.00 49.28 0.0 0.0 2017-01
2017-01-01 00:20:00+01:00 8645.13 2.74 0.0 0.0 0.0 41.69 41.70 19.85 44.43 0.0 0.0 2017-01
2017-01-01 00:25:00+01:00 9079.74 2.90 0.0 0.0 0.0 44.09 44.13 19.77 46.99 0.0 0.0 2017-01
... ... ... ... ... ... ... ... ... ... ... ... ...
2021-03-03 21:40:00+01:00 26521.00 11.63 0.0 0.0 0.0 0.00 0.00 83.00 11.63 0.0 0.0 2021-03
2021-03-03 21:45:00+01:00 26532.00 11.62 0.0 0.0 0.0 0.00 0.00 83.00 11.62 0.0 0.0 2021-03
2021-03-03 21:50:00+01:00 26575.00 11.65 0.0 0.0 0.0 0.00 0.00 83.00 11.65 0.0 0.0 2021-03
2021-03-03 21:55:00+01:00 26449.00 11.60 0.0 0.0 0.0 0.00 0.00 82.00 11.61 0.0 0.0 2021-03
2021-03-03 22:00:00+01:00 26341.00 11.61 0.0 0.0 0.0 0.00 0.00 82.00 11.61 0.0 0.0 2021-03

438552 rows × 12 columns

In [129]:
df_bat = df_bat.dropna()
In [ ]:
 
In [130]:
##Potential zum Laden beim Pendeln:

line1 = "2019-06-18 07:00:00"
line2 = "2019-06-18 17:00:00"

ax.axvspan(line1, line2, alpha=.5, color='red')

plt.show()
In [131]:
start_date="2019-06-18"
end_date="2019-06-19"

zeit = (df['DateTime'] > start_date) & (df['DateTime'] <= end_date)
zeit = df.loc[zeit]

zeit.plot(figsize=(15,10),x="DateTime", y=["FromGen", "ToCons"])
plt.xlabel("Zeit") 
plt.ylabel("Wh")
legend = plt.legend(title="Lastprofil bei maximaler Tageslänge",
                    loc=1, fontsize='large', fancybox=True)

plt.show()
In [132]:
start_date="2019-06-18"
end_date="2019-06-19"

x0='2019-06-18 9:00:00'
x1='2019-06-18 17:00:00'

x0= pd.to_datetime(x0, format="%Y-%m-%d", utc=True)
x1= pd.to_datetime(x1, format="%Y-%m-%d", utc=True)

zeit = (df['DateTime'] > start_date) & (df['DateTime'] <= end_date)
zeit = df.loc[zeit]

zeit.plot(figsize=(15,10),x="DateTime", y=["FromGen", "ToCons"])
plt.xlabel("Zeit") 
plt.ylabel("Wh")
legend = plt.legend(title="Lastprofil",
                    loc=1, fontsize='large', fancybox=True,  labels=['Erzeugung', 'Verbrauch'])
plt.axvline(x=x0, color='red')
plt.axvline(x=x1, color='red')

ax.fill_between(zeit['DateTime'].values, zeit['FromGen'], zeit['ToCons'],
                where=(zeit['FromGen'] > zeit['ToCons']) & ((zeit['DateTime'] <= x0) | (zeit['DateTime'] >= x1)),
                interpolate=False, color='#8FF536')

#plt.axvline(x=0.33088437)
plt.show()
In [133]:
zeit.head(140)
Out[133]:
DateTime DevWork FromBatToCons FromGenToBat FromGenToCons FromGenToGrid FromGridToCons FromGrid StateOfCharge ToCons FromGen Mehrmenge Datum
258588 2019-06-18 00:05:00+02:00 87323.73 27.74 0.00 0.01 0.00 15.18 15.18 53.78 42.93 0.01 0.00 2019-06
258589 2019-06-18 00:10:00+02:00 89692.13 28.46 0.00 0.01 0.00 16.05 16.05 53.03 44.51 0.01 0.00 2019-06
258590 2019-06-18 00:15:00+02:00 94207.05 29.59 0.00 0.01 0.00 16.09 16.09 52.58 45.69 0.01 0.00 2019-06
258591 2019-06-18 00:20:00+02:00 93143.32 29.45 0.00 0.01 0.00 15.82 15.82 51.64 45.27 0.01 0.00 2019-06
258592 2019-06-18 00:25:00+02:00 87642.91 27.72 0.00 0.01 0.00 19.35 19.36 51.08 47.08 0.01 0.00 2019-06
... ... ... ... ... ... ... ... ... ... ... ... ... ...
258723 2019-06-18 11:20:00+02:00 773527.34 2.56 33.27 56.04 179.00 7.27 7.27 90.26 65.88 268.31 212.27 2019-06
258724 2019-06-18 11:25:00+02:00 775786.12 0.90 35.72 50.38 187.04 6.18 6.18 90.93 57.46 273.14 222.76 2019-06
258725 2019-06-18 11:30:00+02:00 808885.97 0.74 31.35 52.98 192.72 6.18 6.18 91.50 59.90 277.05 224.07 2019-06
258726 2019-06-18 11:35:00+02:00 822493.53 0.64 31.00 48.64 201.68 9.05 9.05 91.90 58.33 281.32 232.68 2019-06
258727 2019-06-18 11:40:00+02:00 842433.24 0.77 27.94 57.64 198.68 9.77 9.77 92.43 68.19 284.26 226.62 2019-06

140 rows × 13 columns

In [134]:
#Wir kopieren den ursprünglichen DF für den nächsten Plot (Timezone muss angepasst werden)
df_time=df.copy()
df_time['DateTime'] = pd.to_datetime(df_time['DateTime'], format="%Y-%m-%d", utc=True)
#df_time['DateTime'] = df_time['DateTime'].dt.tz_convert('Europe/Berlin')

#Timezone anpassen:
from datetime import datetime
from pytz import timezone
from datetime import datetime, timedelta


df_time['DateTime'] = df_time['DateTime'] + timedelta(hours=2)
df_time['DateTime'] = df_time['DateTime'].dt.tz_convert('utc')

BEV Potential visualisiert

In [135]:
#hier können jetzt Zeiten definiert werden, an denen das Fahrzeug nicht am Netz hängt.
In [136]:
#Zeitraum der ausgewertet werden soll:
start_date = "2019-06-18"
end_date = "2019-06-19"

#Von-Bis ist das BEV nicht an der ladesäule:
time1="7:00:00"
time2="17:00:00"

x0 = start_date+" "+time1
x1 = start_date+" "+time2


zeit = df_time.loc[(df_time['DateTime'] > start_date) & (df_time['DateTime'] <= end_date)]


ax = zeit.plot(figsize=(15, 10), x="DateTime", y=["FromGen", "ToCons"])

ax.set_xlabel("Zeit")
ax.set_ylabel("Wh")
legend = ax.legend(title="",
                   loc='upper right', fontsize='large', fancybox=True, labels=['Erzeugung', 'Verbrauch'])
ax.axvline(x=x0, color='red')
ax.axvline(x=x1, color='red')


ax.fill_between(zeit['DateTime'].values, zeit['FromGen'], zeit['ToCons'],
                where=((zeit['FromGen'] > zeit['ToCons']) & ((zeit['DateTime'] <= x0) | (zeit['DateTime'] >=x1))),
                interpolate=False, color='#8FF536')
plt.show()
In [137]:
#df
In [138]:
#df_time
In [ ]:
 
In [ ]: